home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / aminet / biz / misc / imagefxdevkit.lha / doc / Ged.autodoc next >
Text File  |  1992-12-14  |  25KB  |  767 lines
  1. TABLE OF CONTENTS
  2.  
  3. ged/--background--
  4. ged/--styles--
  5. ged/GedWin
  6. ged/GedWindow
  7. ged/Ged_Activate
  8. ged/Ged_Add
  9. ged/Ged_Create
  10. ged/Ged_Delete
  11. ged/Ged_Enable
  12. ged/Ged_Get
  13. ged/Ged_GetIMsg
  14. ged/Ged_Remove
  15. ged/Ged_Set
  16.  
  17.  
  18.  
  19.  
  20. ged/--background--                                    ged/--background--
  21.  
  22.     What the heck *is* Ged, anyway?  Well, I'll tell you...
  23.  
  24.     At the conception of Scan, I realized very quickly that I was going
  25.     to need a way to shorten the time it took to create the gadgets and
  26.     windows and stuff needed for the program.  The idea was to come up
  27.     with a 2.0 look and feel, without actually requiring 2.0 to run
  28.     (grumble, grumble).  So I quickly hacked together a little gadget
  29.     editor program to make life a little easier.
  30.  
  31.     Well, originally this little gadget editor was just going to spit out
  32.     Gadget structures, but after playing around with it a while I thought
  33.     it would be better to come up with my own GadTools-like system.  Hence
  34.     the NewGad structure was born.  The idea was to pass an array of
  35.     NewGad structures to a single gadget creating function that would
  36.     return a pointer to a list of Gadget's, suitable for adding to a
  37.     window (sound familiar?).
  38.  
  39.     As these things often do, Ged kinda grew completely out of control.
  40.     In addition to gadgets, I added the ability to specify text, border,
  41.     and even imagery in the list of NewGad's.  It also became somewhat
  42.     object-oriented in that each NewGad can specify a function to call
  43.     when that gadget is "fiddled" with (one of the things I find sorely
  44.     lacking in GadTools).
  45.  
  46.     Anyway, the following is an attempt at documenting how the Ged system
  47.     works so that you can use it in creating your own modules for
  48.     Scan (it is required for Scanner, Render, Printer, and some aspects
  49.     of Preview modules).  These functions are contained in the scan.library
  50.     function library.
  51.  
  52.     BTW, if you're wondering about the Ged creator program, it's way
  53.     too hacked up and obsolete to be useful anymore.
  54.  
  55.     All of the functions described below are contained in the ImageFX function
  56.     library (scan*.library).
  57.  
  58.  
  59. ged/--styles--                                                 ged/--styles--
  60.  
  61.     A complete catalog of the types of GUI elements that can be created with
  62.     the Ged system:
  63.  
  64.         Button_ID:
  65.             A standard BOOLGADGET button, with a bevel box border.  The label
  66.             always appears inside the gadget.
  67.  
  68.         Toggle_ID:
  69.             Looks like a button, but really toggles between two states.  The
  70.             label always appears inside the gadget.  I wouldn't use this too
  71.             often, as it isn't really very AUISG compliant.
  72.  
  73.         String_ID:
  74.             A standard string gadget, with the 2.0 look border around it.  The
  75.             label always appears to the left of the gadget.
  76.  
  77.         Integer_ID:
  78.             A standard LONGINT string gadget, with the 2.0 look border
  79.             around it.  The label always appears to the left of the gadget.
  80.  
  81.         HSlider_ID:
  82.             Horizontal slider (PROPGADGET), with a bevel border.  The label
  83.             always appears to the left of the gadget.
  84.  
  85.         VSlider_ID:
  86.             Vertical slider (PROPGADGET), with a bevel border.  The label
  87.             always appears above the gadget.
  88.  
  89.         Cycle_ID:
  90.             2.0-style cycle gadget, for cycling through a list of choices.
  91.             Ged breaks away a little from the style guide here in the way it
  92.             handles these kinds of gadgets.  Clicking the right side of the
  93.             gadget cycles upwards, clicking the left side of the gadget cycles
  94.             downwards, and double-clicking in the middle of the gadget brings
  95.             up a list of all the choices in the gadget.  A tool type
  96.             (GTCOMPLIANT) in ImageFX will disable all this fancy stuff if
  97.             you're used to standard GadTools-type cycler gadgets.
  98.  
  99.             There is also no way to attach a label to a Ged cycle gadget; you
  100.             have to use a Text_ID item and place a text near it.
  101.  
  102.         Check_ID:
  103.             2.0-style checkbox gadget.  Gadget labels always appears on the
  104.             right side of the checkbox.
  105.  
  106.         MX_ID:
  107.             2.0-style mutual exclusion (radio) gadget.  Note that Ged does
  108.             *NOT* do any mutual exclusion - this gadget behaves just like a
  109.             checkbox gadget.  The only difference is the imagery.  You must
  110.             still do the mutual exclusion yourself.  The label always appears
  111.             on the right side of the gadget.
  112.  
  113.         Border_ID:
  114.             Draw a bevel-box border, raised or recessed.
  115.  
  116.         Text_ID:
  117.             Draw a string of text.
  118.  
  119.         Image_ID:
  120.             Display an Image structure.
  121.  
  122.         End_ID:
  123.             Used to end an array of NewGad structure.
  124.  
  125.  
  126.     The following styles will not be used often, if ever:
  127.  
  128.         QButton_ID:
  129.             Same as Button_ID with no imagery.
  130.  
  131.         QToggle_ID:
  132.             Same as Toggle_ID with no imagery.
  133.  
  134.         QString_ID:
  135.             Same as String_ID with no imagery.
  136.  
  137.         QInteger_ID:
  138.             Same as Integer_ID with no imagery.
  139.  
  140.         QHSlider_ID:
  141.             Same as HSlider_ID with no imagery.
  142.  
  143.         QVSlider_ID:
  144.             Same as VSlider_ID with no imagery.
  145.  
  146.         QCycle_ID:
  147.             Same as Cycle_ID with no imagery.
  148.  
  149.         QCheck_ID:
  150.             Same as Check_ID with no imagery.
  151.  
  152.         QMX_ID:
  153.             Same as MX_ID with no imagery.
  154.  
  155.  
  156.     Special non-GUI styles:
  157.  
  158.         Ignore_ID:
  159.             Not implemented.
  160.  
  161.         Font_ID:
  162.             Not implemented.
  163.  
  164.         Offset_ID:
  165.             Internal use only.
  166.  
  167.         Scale_ID:
  168.             Specify this style as the first in your NewGad array, and layout
  169.             your gadgets based on an 8-point font.  The Ged system will
  170.             automatically scale the sizes and positions of your GUI elements
  171.             to fit the font that the user specified for ImageFX.  You should
  172.             use this only for opening windows on the ImageFX screen.  ImageFX
  173.             itself uses this for most of its displays.
  174.  
  175.  
  176. ged/GedWin                                                         ged/GedWin
  177.  
  178.     NAME
  179.         GedWin -- Somewhat higher-level version of GedWindow().
  180.  
  181.     SYNOPSIS
  182.         returnCode = GedWin ( newWindow, newGadArray, activateID,
  183.         D0.L                  A0         A1           D0.L
  184.                               initCode, cleanupCode, textArray )
  185.                               A2        A3           A4
  186.  
  187.         int GedWin ( struct NewWindow *newWindow,
  188.                      struct NewGad *newGadArray,
  189.                      int activateID,
  190.                      int (*initCode)(struct Window *, struct NewGad *),
  191.                      int (*cleanupCode)(struct Window *, struct Gadget *),
  192.                      char **textArray );
  193.  
  194.     FUNCTION
  195.         Open a new window, add gadgets to it, process the events of the
  196.         window, and return only when the window is closed.  This is a
  197.         convenient do-it-all function for opening requesters and such
  198.         containing Ged gadgets.
  199.  
  200.         This function is meant specifically for opening windows on the ImageFX
  201.         screen.  It will make sure the ImageFX screen is in front, roll the
  202.         screen up far enough to hold the window, and block all input to other
  203.         ImageFX windows before opening this new window.
  204.  
  205.         In all other respects, this function is identical to GedWindow().
  206.  
  207.     INPUTS
  208.         See GedWindow().
  209.  
  210.     RESULTS
  211.         See GedWindow().
  212.  
  213.     EXAMPLE
  214.         See GedWindow().
  215.  
  216.     NOTES
  217.  
  218.     BUGS
  219.  
  220.     SEE ALSO
  221.         ged/GedWindow
  222.  
  223.  
  224. ged/GedWindow                                                   ged/GedWindow
  225.  
  226.     NAME
  227.         GedWindow -- Open and handle a window with Ged gadgets.
  228.  
  229.     SYNOPSIS
  230.         returnCode = GedWindow ( newWindow, newGadArray, activateID,
  231.         D0.L                     A0         A1           D0.L
  232.                                  initCode, cleanupCode, textArray )
  233.                                  A2        A3           A4
  234.  
  235.         int GedWindow ( struct NewWindow *newWindow,
  236.                         struct NewGad *newGadArray,
  237.                         int activateID,
  238.                         int (*initCode)(struct Window *, struct NewGad *),
  239.                         int (*cleanupCode)(struct Window *, struct Gadget *),
  240.                         char **textArray );
  241.  
  242.     FUNCTION
  243.         Open a new window, add gadgets to it, process the events of the
  244.         window, and return only when the window is closed.  This is a
  245.         convenient do-it-all function for opening requesters and such
  246.         containing Ged gadgets.
  247.  
  248.         There are two ways to have the window closed.  One is to specify a
  249.         close gadget in the NewWindow structure, in which case this function
  250.         will return -1 when the close gadget is pressed.  The other way is to
  251.         make sure that one or more of your Ged gadgets have a code pointer
  252.         that returns a non-zero value.  You may also specify in the NewGad
  253.         structure of Button_ID gadgets that a non-zero value be returned
  254.         without the need for a user-supplied function.
  255.  
  256.         An alert will be presented if the window open fails, and a -2 will be
  257.         returned.
  258.  
  259.         If this window is opened on the ImageFX screen, pressing the right
  260.         mouse button any time while this window is open will toggle the
  261.         menu panel on or off.
  262.  
  263.         If you are opening this window on the ImageFX screen, you may want to
  264.         consider using the GedWin() function instead.
  265.  
  266.         If you need to do anything fancy (like menus, for example) you will
  267.         not be able to use this function.
  268.  
  269.     INPUTS
  270.         newWindow -- a pointer to a NewWindow structure used to open the
  271.                     window.  Note that you must make sure that you select the
  272.                     proper IDCMP flags for the gadget styles you have chosen
  273.                     for this window.
  274.  
  275.         newGadArray -- pointer to an array of NewGad structures, each
  276.                     element of which describes a UI feature (gadget,
  277.                     text, image, or bevel box).  The contents of each
  278.                     NewGad structure depends on the Style chosen
  279.                     (see scan/ged.h for details of the NewGad struct).
  280.  
  281.         activateID -- if non-zero, this should be a string or integer
  282.                     gadget ID number to automatically activate when the
  283.                     window opens.
  284.  
  285.         initCode -- User-supplied code to call to initialize certain things
  286.                     during the process of opening the window.  This function
  287.                     will actually be called twice during the initialization
  288.                     process.  The first time, the NewGad * argument will be
  289.                     valid.  The second time, the Window * argument will be
  290.                     valid.  The invalid argument will be NULL.  Most times you
  291.                     will not need to use these functions.
  292.  
  293.         cleanupCode -- User-supplied code to call during the cleanup process.
  294.  
  295.         textArray -- Array of text pointers to be supplied to Ged_Create().
  296.  
  297.  
  298.     RESULTS
  299.         Returns the result code of the gadget that terminated the window,
  300.         or -1 if the close gadget was pressed.  This function will not return
  301.         until the window is closed one way or another.
  302.  
  303.     EXAMPLE
  304.  
  305.         /*
  306.          * Simple window with nothing but an Okay and Cancel gadget.
  307.          *
  308.          */
  309.  
  310.         extern struct ScanBase *ScanBase;
  311.  
  312.         /* Text indexes */
  313.         enum {
  314.             G_Okay = 1,
  315.             G_Cancel
  316.         };
  317.  
  318.         /* Text string array */
  319.         char *textArray[] = {
  320.             NULL,
  321.             "_Okay",        /* note underscore to make keyboard shortcut */
  322.             "_Cancel"
  323.         };
  324.  
  325.         /* Gadget ID's */
  326.         enum {
  327.             ID_Okay = 100,
  328.             ID_Cancel
  329.         };
  330.  
  331.         /* GUI definition */
  332.         struct NewGad newGads[] = {
  333.             { Button_ID, ID_Okay, 8,18,90,12, G_Okay, NULL,0, NULL, ID_Okay,0,NULL,0 },
  334.             { Button_ID, ID_Cancel, 294,18,90,12, G_Cancel, NULL,0, NULL, ID_Cancel,0,NULL,0 },
  335.             { Border_ID, 0, 0,0,421,34, NULL,NULL,0,NULL, FALSE,TRUE,0,0 },
  336.             { End_ID }
  337.         };
  338.  
  339.         /* Window definition */
  340.         struct NewWindow newWindow = {
  341.             9,13,421,64,
  342.             0,1,
  343.             GADGETUP,
  344.             BORDERLESS|ACTIVATE|NOCAREREFRESH|SMART_REFRESH|RMBTRAP,
  345.             NULL,
  346.             NULL,
  347.             NULL,
  348.             NULL,
  349.             NULL,
  350.             40,20,-1,-1,
  351.             CUSTOMSCREEN
  352.         };
  353.  
  354.         void TestGedWindow (void)
  355.         {
  356.             int rc;
  357.  
  358.             rc = GedWindow(&newWindow, boolNewGads, 0, NULL, NULL, textArray);
  359.  
  360.             switch(rc) {
  361.                 case ID_Okay :
  362.                     printf("ok!\n");
  363.                     break;
  364.                 case ID_Cancel :
  365.                     printf("cancel!\n");
  366.                     break;
  367.                 default :
  368.                     printf("oops.\n");
  369.                     break;
  370.             }
  371.         }
  372.  
  373.     NOTES
  374.  
  375.     BUGS
  376.  
  377.     SEE ALSO
  378.         ged/GedWin
  379.  
  380.  
  381. ged/Ged_Activate                                         ged/Ged_Activate
  382.  
  383.     NAME
  384.         Ged_Activate -- Activate a string or integer gadget.
  385.  
  386.     SYNOPSIS
  387.         Ged_Activate ( window, gadgetid )
  388.                        A0      D0.L
  389.  
  390.         void Ged_Activate ( struct Window *window, int gadgetid );
  391.  
  392.     FUNCTION
  393.         Attempts to activate the gadget identified by the ID value
  394.         given in the supplied window.  Of course, this only works
  395.         for String_ID and Integer_ID style gadgets.
  396.  
  397.     INPUTS
  398.         window -- pointer to the window where the gadget resides.
  399.         id -- ID value of the gadget to activate.
  400.  
  401.     RESULT
  402.         None.
  403.  
  404.     EXAMPLE
  405.  
  406.     NOTES
  407.  
  408.     SEE ALSO
  409.  
  410.  
  411.  
  412. ged/Ged_Add                                                   ged/Ged_Add
  413.  
  414.     NAME
  415.         Ged_Add -- Add a Ged context to a window.
  416.  
  417.     SYNOPSIS
  418.         Ged_Add ( context, window )
  419.                   A0       A1
  420.  
  421.         void Ged_Add ( struct GedContext *context, struct Window *window );
  422.  
  423.     FUNCTION
  424.         Adds (ie. draws) the imagery specified by the supplied GedContext
  425.         to the given window.  This includes gadgets, text, bevel borders,
  426.         and images.
  427.  
  428.     INPUTS
  429.         context -- pointer to a GedContext structure, which has been filled
  430.                     in by a call to Ged_Create().
  431.         window -- pointer to the Window in which to add the context.
  432.  
  433.     RESULT
  434.         None.
  435.  
  436.     EXAMPLE
  437.  
  438.     NOTES
  439.         The normal procedure to follow is something like this:
  440.  
  441.             if (Ged_Create(&context, newGadArray)) {
  442.                 Ged_Add(&context, window);
  443.                 /* do window stuff */
  444.                 Ged_Remove(&context, window);
  445.                 Ged_Delete(&context);
  446.             }
  447.  
  448.     SEE ALSO
  449.         ged/Ged_Create,ged/Ged_Remove
  450.  
  451.  
  452.  
  453. ged/Ged_Create                                               ged/Ged_Create
  454.  
  455.     NAME
  456.         Ged_Create -- Allocate a complete Ged context based on an input
  457.                         array of gadget, text, border, and image
  458.                         specifications.
  459.  
  460.     SYNOPSIS
  461.         success = Ged_Create ( context, newGadArray, textArray )
  462.                                A0       A1           A2
  463.  
  464.         int Ged_Create ( struct GedContext *context,
  465.                          struct NewGad *newGadArray,
  466.                          char **textArray );
  467.  
  468.     FUNCTION
  469.         Fills in the supplied GedContext structure with pointers to
  470.         lists of Gadget, IntuiText, Border, and Images suitable for
  471.         adding to a window with Ged_Add().  Dynamically allocates Gadget
  472.         structures based on the information contained in the input array
  473.         of NewGad specifiers; this list also contains information on where
  474.         and how to place text, borders, and images.
  475.  
  476.     INPUTS
  477.         context -- pointer to GedContext structure which is filled
  478.                     with a bunch of (read only) information.
  479.  
  480.         newGadArray -- pointer to an array of NewGad structures, each
  481.                     element of which describes a UI feature (gadget,
  482.                     text, image, or bevel box).  The contents of each
  483.                     NewGad structure depends on the Style chosen
  484.                     (see scan/ged.h for details of the NewGad struct).
  485.  
  486.         textArray -- pointer to an array of text strings.  Each NewGad
  487.                     should specify it's label as an index into this
  488.                     text array, so that they may be internationalized
  489.                     fairly easily.  If this pointer is NULL, ImageFX
  490.                     will assume that each NewGad.Label is really a
  491.                     pointer to a (char *) string.
  492.  
  493.     RESULT
  494.         success -- 0 if the function failed, non-zero if successful.
  495.  
  496.     EXAMPLE
  497.  
  498.     NOTES
  499.         The newGadArray must remain valid throughout the entire lifetime of
  500.         the gadgets, as the NewGad structure that created a gadget is
  501.         referenced whenever a gadget is fiddled with.  For example, when a
  502.         slider gadget is adjusted, the new value of the slider is stored in
  503.         the NewGad that created the slider.
  504.  
  505.         Also note that each gadget's Pointer argument (as specified in the
  506.         NewGad structure) must remain valid throughout the lifetime of the
  507.         gadgets, as they are updated whenever a gadget is modified.  They are
  508.         also initialized immediately.
  509.  
  510.     SEE ALSO
  511.         ged/Ged_Delete,scan/ged.h
  512.  
  513.  
  514. ged/Ged_Delete                                                 ged/Ged_Delete
  515.  
  516.     NAME
  517.         Ged_Delete -- Free all memory associated with a Ged context.
  518.  
  519.     SYNOPSIS
  520.         Ged_Delete ( context )
  521.                      A0
  522.  
  523.         void Ged_Delete ( struct GedContext *context );
  524.  
  525.     FUNCTION
  526.         Frees all memory associated with the given GedContext structure.
  527.         When this function returns, all pointers within the GedContext
  528.         structure are invalid.
  529.  
  530.     INPUTS
  531.         context -- pointer to GedContext structure as filled in by
  532.                     the Ged_Create() function.
  533.  
  534.     RESULTS
  535.         None.
  536.  
  537.     EXAMPLE
  538.  
  539.     NOTES
  540.  
  541.     BUGS
  542.  
  543.     SEE ALSO
  544.         ged/Ged_Create
  545.  
  546.  
  547. ged/Ged_Enable                                                 ged/Ged_Enable
  548.  
  549.     NAME
  550.         Ged_Enable -- Enable or disable (ghost) a Ged gadget.
  551.  
  552.     SYNOPSIS
  553.         Ged_Enable ( window, gadgetID, enable )
  554.                      A0      D0.W      D1.W
  555.  
  556.         void Ged_Enable ( struct Window *window,
  557.                           short gadgetID,
  558.                           short enable );
  559.  
  560.     FUNCTION
  561.         Use this function to enable or disable a Ged gadget.  Disabling a
  562.         gadget prevents the user from accessing it.  The gadget imagery will
  563.         be refreshed immediately.
  564.  
  565.     INPUTS
  566.         window -- pointer to the Window containing the gadgets.
  567.  
  568.         gadgetID -- the ID number of the gadget you wish to examine.
  569.  
  570.         enable -- flag indication whether you want to enable or disable the
  571.                     gadget.  Use a non-zero value to enable the gadget, or
  572.                     zero to disable (ghost) the gadget.
  573.  
  574.     RESULTS
  575.         None.
  576.  
  577.     EXAMPLE
  578.  
  579.     NOTES
  580.  
  581.     BUGS
  582.  
  583.     SEE ALSO
  584.  
  585.  
  586. ged/Ged_Get                                                       ged/Ged_Get
  587.  
  588.     NAME
  589.         Ged_Get -- return the state of a given Ged gadget.
  590.  
  591.     SYNOPSIS
  592.         value = Ged_Get ( window, gadgetID )
  593.         D0.L              A0      D0.W
  594.  
  595.         long Ged_Get ( struct Window *window, short gadgetID );
  596.  
  597.     FUNCTION
  598.         Returns the current state (value) of any Ged gadget in a window.
  599.         The return value will differ depending on the style of gadget you are
  600.         examining (see below).
  601.  
  602.     INPUTS
  603.         window -- pointer to the Window containing the gadgets.
  604.  
  605.         gadgetID -- the ID number of the gadget you wish to examine.
  606.  
  607.     RESULTS
  608.         value -- the current value of the gadget.  The returned value and type
  609.                     depends on the style of gadget you are examining:
  610.  
  611.                     Button_ID   (long) Always 0.
  612.                     Toggle_ID   (long) Selection state (1=on, 0=off).
  613.                     MX_ID       (long) Selection state (1=on, 0=off).
  614.                     Check_ID    (long) Selection state (1=on, 0=off).
  615.                     String_ID   (char *) String contents.
  616.                     Integer_ID  (long) Integer value.
  617.                     HSlider_ID  (long) Slider value.
  618.                     VSlider_ID  (long) Slider value.
  619.                     Cycle_ID    (long) Cycle index.
  620.  
  621.     EXAMPLE
  622.  
  623.     NOTES
  624.         Examining a gadget's Pointer variable will accomplish the same thing.
  625.  
  626.     BUGS
  627.  
  628.     SEE ALSO
  629.         ged/Ged_Set
  630.  
  631.  
  632. ged/Ged_GetIMsg                                               ged/Ged_GetIMsg
  633.  
  634.     NAME
  635.         Ged_GetIMsg -- Handle Ged gadget events.
  636.  
  637.     SYNOPSIS
  638.         intuiMsg = Ged_GetIMsg ( window, &returnCode )
  639.         D0.L                     A0.L    A1.L
  640.  
  641.         struct IntuiMessage *Ged_GetIMsg ( struct Window *window,
  642.                                            short *returnCode );
  643.  
  644.     FUNCTION
  645.         Process events from the given window, filtering out those events which
  646.         pertain only to Ged gadgets.  If an event is found to be a Ged event,
  647.         then the event is processed and the results of the processing are
  648.         stored in the variable that returnCode points to.
  649.  
  650.         When Ged gadget activity is detected, the Ged system will update the
  651.         gadget imagery as necessary, then call the optional user-supplied code
  652.         (set with NewGad.Code) for the gadget.  The return value from this user-
  653.         supplied code is placed in the variable that returnCode points to.  A
  654.         zero result generally means everything went alright.
  655.  
  656.     INPUTS
  657.         window -- pointer to the Window to process.
  658.  
  659.         returnCode -- where to store the return codes from any user-supplied
  660.                     code processed by the Ged system.
  661.  
  662.     RESULTS
  663.         intuiMsg -- If this event is not of a type that Ged cares about, then
  664.                     the IntuiMessage is returned for you to process normally.
  665.                     If Ged did in fact process the event, NULL is returned.
  666.  
  667.     EXAMPLE
  668.  
  669.     NOTES
  670.  
  671.     BUGS
  672.  
  673.     SEE ALSO
  674.  
  675.  
  676. ged/Ged_Remove                                                 ged/Ged_Remove
  677.  
  678.     NAME
  679.         Ged_Remove -- Remove a Ged context from a window.
  680.  
  681.     SYNOPSIS
  682.         Ged_Remove ( context )
  683.                      A0
  684.  
  685.         void Ged_Remove ( struct GedContext *context );
  686.  
  687.     FUNCTION
  688.         Remove all the gadgets in the Ged context from the window that
  689.         this context was added to (with Ged_Add()).
  690.  
  691.     INPUTS
  692.         context -- pointer to GedContext as filled in by the Ged_Create()
  693.                     function.
  694.  
  695.     RESULTS
  696.         None.
  697.  
  698.     EXAMPLE
  699.  
  700.     NOTES
  701.  
  702.     BUGS
  703.  
  704.     SEE ALSO
  705.         ged/Ged_Add
  706.  
  707.  
  708. ged/Ged_Set                                                       ged/Ged_Set
  709.  
  710.     NAME
  711.         Ged_Set -- Set the state of a Ged gadget.
  712.  
  713.     SYNOPSIS
  714.         Ged_Set ( window, gadgetID, newValue )
  715.                   A0      D0.W      D1.L
  716.  
  717.         void Ged_Set ( struct Window *window,
  718.                        short gadgetID,
  719.                        long newValue );
  720.  
  721.     FUNCTION
  722.         Set the state of a gadget, that is, the contents of a string
  723.         or integer gadget, the value of a slider gadget, or the selection state
  724.         of checkbox or toggle gadgets.
  725.  
  726.     INPUTS
  727.         window -- window containing the gadgets.
  728.  
  729.         gadgetID -- the ID number of the gadget you wish to modify.
  730.  
  731.         newValue -- new value to store in the given gadget.  The value depends
  732.                     on the type of gadget you are modifying:
  733.  
  734.                     Button_ID   Ignored.
  735.                     Toggle_ID   (long) Selection state (1=on, 0=off).
  736.                     MX_ID       (long) Selection state (1=on, 0=off).
  737.                     Check_ID    (long) Selection state (1=on, 0=off).
  738.                     String_ID   (char *) New string contents.
  739.                     Integer_ID  (long) New integer value.
  740.                     HSlider_ID  (long) New slider value.
  741.                     VSlider_ID  (long) New slider value.
  742.                     Cycle_ID    (long) New cycle index.
  743.  
  744.                     Note that there is no range checking on the value you
  745.                     supply.
  746.  
  747.                     The gadget imagery will be refreshed.
  748.  
  749.                     The gadget's Pointer variable (if present) will be updated.
  750.  
  751.     RESULTS
  752.         None.
  753.  
  754.     EXAMPLE
  755.  
  756.     NOTES
  757.         For slider gadgets (styles HSlider_ID and VSlider_ID), the gadgets
  758.         Code function will be called when the imagery is refreshed.  The is
  759.         because in most cases, the code for a slider gadget is used to update
  760.         a numerical value somewhere near the slider.
  761.  
  762.     BUGS
  763.  
  764.     SEE ALSO
  765.         ged/Ged_Get
  766.  
  767.